package kylintool.util;

/**
 * <p>标题： </p>
 * <p>功能：与安全或者加密有关的工具 </p>
 * <p>版权： Copyright © 2013 SNSOFT</p>
 * <p>公司: 北京南北天地科技股份有限公司</p>
 * <p>创建日期：2013-5-14 上午10:57:07</p>
 * <p>类全名：snsoft.rootbas.util.pub.SecurityUtil</p>
 * 作者：王立鹏
 * 初审：
 * 复审：
 * 监听使用界面:
 * @version 8.0
 * 		除非需要流,否则尽量使用ByteBuffer代替ByteArrayInputStream
 * 		所有的加密算法,方法名都是encodeXXX或者encryptXXX(非对称算法,需要事先生成密钥对),
 * 			对应的解码是decodeXXX或者decryptXXX(非对称算法,需要事先生成密钥对)
 * 
 * 	使用说明:
 * 		摘要算法有(复杂的从低到高):encodeMD5,encodeSHA1(一般用于文件数字认证)
 * 		对称加密算法有(复杂的从低到高):encodeSnPwd,encodeSimpleXor,encodeAES
 * 			将二进制字节信息转为字符串的方法有(复杂的从低到高):encodeHex(效率很高),encodeBASE64
 * 				注意:加密后如果是byte[],如果需要转为字符串,可以使用上面两种方式,
 * 				*如果转化后的字符串仅是咱们自己使用,建议用encodeHex方式.*
 * 		非对称加密算法有(复杂的从低到高):encryptRSA(生成密钥的方法是:generateRSAPairKey)
 */
public class SecurityUtil{
//{
//	/*------------------------------------------对称算法--------------------------------------------*/
//	/**
//	 * 将二进制数据进行Base64编码
//	 * @param bytes 二进制字节数据
//	 * @return 编码后的文本
//	 * @throws IOException
//	 */
//	public static String encodeBASE64(final byte[] original) throws IOException
//	{
//		return Base64.getEncoder().encodeToString(original);
//	}
//
//	public static String encodeBASE64(final String original) throws IOException
//	{
//		if (original == null || original.length() == 0)
//		{
//			throw new NullPointerException("非法的参数:original,original不能为null!");
//		}
//		final byte[] bytes = original.getBytes("UTF-8");
//		return Base64Encode.encode(bytes);
//	}
//
//	/**
//	 * 将文件进行Base64解码
//	 * @param ciphertext 文本
//	 * @return 解码后的二进制数据
//	 */
//	public static byte[] decodeBASE64(final String ciphertext, final boolean skipBlank) throws IOException
//	{
//		return Base64Decode.decode(ciphertext, skipBlank);
//	}
//
//	/**
//	 * 将文件进行Base64解码
//	 * @param ciphertext 文本
//	 * @param skipBlank 忽略回车符
//	 * @return 解码后的二进制数据
//	 */
//	public static byte[] decodeBASE64(final byte[] ciphertext, final boolean skipBlank) throws IOException
//	{
//		Base64Decode decode = new Base64Decode(ciphertext);
//		decode.setSkipBlank(skipBlank);
//		return DataStream.toByteArray(decode);
//	}
//
//	public static String decodeBASE64AsString(final String ciphertext, final boolean skipBlank) throws IOException
//	{
//		final byte[] ba = Base64Decode.decode(ciphertext, skipBlank);
//		return new String(ba, "UTF-8");
//	}
//
//	/**
//	 * 将二进制内容转为字符串
//	 * @param original
//	 * @return
//	 */
//	public static String encodeHex(final byte[] original)
//	{
//		if (original == null || original.length == 0)
//		{
//			return "";
//		}
//		final char sa[] = new char[original.length * 2];
//		for (int i = 0; i < original.length; i++)
//		{
//			int x = original[i] >> 4 & 0xf;//高四位
//			sa[i * 2] = (char) (x < 10 ? '0' + x : 'A' + x - 10);
//			x = original[i] & 0xf;//低四位
//			sa[i * 2 + 1] = (char) (x < 10 ? '0' + x : 'A' + x - 10);
//		}
//		return new String(sa);
//	}
//
//	/**
//	 * 将字符串转为二进制(字节)数组
//	 * @param ciphertext
//	 * @return
//	 */
//	public static byte[] decodeHex(final String ciphertext)
//	{
//		if (ciphertext == null || ciphertext.length() == 0)
//		{
//			return null;
//		}
//		final char[] ciphertextArray = ciphertext.toCharArray();
//		if ((ciphertextArray.length & 2) == 1)
//		{//传入的值有错误
//			return null;
//		}
//		final byte[] b = new byte[ciphertextArray.length / 2];
//		for (int i = 0; i < ciphertextArray.length / 2; i++)
//		{
//			int x = (ciphertextArray[2 * i] < 'A' ? ciphertextArray[2 * i] - '0' : ciphertextArray[2 * i] - 'A' + 10) & 0xf;
//			x = x << 4 | (ciphertextArray[2 * i + 1] < 'A' ? ciphertextArray[2 * i + 1] - '0' : ciphertextArray[2 * i + 1] - 'A' + 10) & 0xf;
//			b[i] = (byte) x;
//		}
//		return b;
//	}
//
//	/**
//	 * 使用南北的密码加密算法进行加密
//	 * @param original 原文
//	 * @return ciphertext 密文
//	 */
//	public static String encodeSnPwd(final String original) throws IOException
//	{
//		return StrUtil.convertPasswordString(original, true);
//	}
//
//	/**
//	 * 使用南北的密码加密算法,进行解密
//	 * @param ciphertext 密文
//	 * @return 原文
//	 */
//	public static String decodeSnPwd(final String ciphertext) throws IOException
//	{
//		return StrUtil.convertPasswordString(ciphertext, false);
//	}
//
//	private static final String	simpleXorKey	= "BeiJingNanbeitiandiKejiGufenYouxianGongsi-100083";	//简单异或加密的密钥
//
//	/**
//	 * 简单异或加密
//	 * @param original 原文
//	 * @return 密文
//	 * 		同时知道原文和密文的情况下,很容易能对出密钥的值
//	 */
//	public static String encodeSimpleXor(final String original)
//	{
//		return SecurityUtil.encodeSimpleXor(original, SecurityUtil.simpleXorKey);
//	}
//
//	/**
//	 * 简单异或加密
//	 * @param original 原文
//	 * @param key 密钥字符串
//	 * @return 密文
//	 * 		同时知道原文和密文的情况下,很容易能对出密钥的值
//	 */
//	public static String encodeSimpleXor(final String original, final String key)
//	{
//		if (original == null || original.length() == 0 || key == null || key.length() == 0)
//		{
//			return original;
//		}
//		final char[] keyChar = key.toCharArray();
//		final char[] originalChar = original.toCharArray();
//		for (int i = 0; i < originalChar.length; i++)
//		{
//			originalChar[i] ^= keyChar[i % keyChar.length];
//		}
//		return "`" + new String(originalChar) + "`";
//	}
//
//	/**
//	 * 简单异或解密
//	 * @param ciphertext 密文
//	 * @return 原文
//	 * 		同时知道原文和密文的情况下,很容易能对出密钥的值
//	 */
//	public static String decodeSimpleXor(final String ciphertext)
//	{
//		return SecurityUtil.decodeSimpleXor(ciphertext, SecurityUtil.simpleXorKey);
//	}
//
//	/**
//	 * 简单异或解密
//	 * @param ciphertext 密文
//	 * @param key 密钥字符串
//	 * @return 原文
//	 * 		同时知道原文和密文的情况下,很容易能对出密钥的值
//	 */
//	public static String decodeSimpleXor(String ciphertext, final String key)
//	{
//		if (ciphertext == null || ciphertext.length() < 2 || key == null || key.length() == 0)
//		{
//			return ciphertext;
//		}
//		final int lCiphertext = ciphertext.length();
//		if (lCiphertext >= 2 && ciphertext.charAt(0) == '`' && ciphertext.charAt(lCiphertext - 1) == '`')
//		{
//			ciphertext = ciphertext.substring(1, lCiphertext - 1);
//			final char[] keyChar = key.toCharArray();
//			final char[] ciphertextChar = ciphertext.toCharArray();
//			for (int i = 0; i < ciphertextChar.length; i++)
//			{
//				ciphertextChar[i] ^= keyChar[i % keyChar.length];
//			}
//			ciphertext = new String(ciphertextChar);
//		}
//		return ciphertext;
//	}
//
//	public static String encodeAES(final String original, String key, String secretiv) throws IllegalBlockSizeException, BadPaddingException, NoSuchProviderException
//	{
//		return encodeAES(original, key, secretiv, null);
//	}
//
//	//判断Key是否正确
//	/**
//	 * AES加密算法
//	 * @param original 原文
//	 * @param key key
//	 * @return
//	 */
//	public static String encodeAES(final String original, String key, String secretiv, String provider) throws IllegalBlockSizeException, BadPaddingException, NoSuchProviderException
//	{
//		if (original == null || original.length() == 0)
//		{
//			return null;
//		}
//		if (key == null || key.length() == 0)
//		{
//			key = "yh@snsoft.com.cn";
//		}
//		key = StrUtil.getEquilongString(key, 16);
//		try
//		{
//			KeyGenerator kgen = KeyGenerator.getInstance("AES");
//			SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
//			secureRandom.setSeed(key.getBytes());
//			kgen.init(128, secureRandom);
//			final byte[] raw = kgen.generateKey().getEncoded();
//			final SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
//			Cipher cipher = null;
//			if (StrUtil.isNotStrTrimNull(provider))
//			{
//				cipher = Cipher.getInstance("AES", provider);
//			} else
//			{
//				cipher = Cipher.getInstance("AES");
//			}
//			if (secretiv == null || secretiv.length() == 0)
//			{
//				cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
//			} else
//			{
//				final IvParameterSpec iv = new IvParameterSpec(secretiv.getBytes());
//				cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
//			}
//			final byte[] encrypted = cipher.doFinal(original.getBytes("UTF-8"));
//			return SecurityUtil.encodeBASE64(encrypted);
//		} catch (NoSuchAlgorithmException | IOException | NoSuchPaddingException | InvalidKeyException | InvalidAlgorithmParameterException e)
//		{
//			throw new RuntimeException("加密算法初始化失败!", e);
//		}
//	}
//
//	public static String encodeAES(final String original) throws IllegalBlockSizeException, BadPaddingException, NoSuchProviderException
//	{
//		return SecurityUtil.encodeAES(original, "yh@snsoft.com.cn", null);
//	}
//
//	public static String decodeAES(final byte[] ciphertext, String key, String secretiv) throws IllegalBlockSizeException, BadPaddingException, NoSuchProviderException
//	{
//		return decodeAES(ciphertext, key, secretiv, null);
//	}
//
//	/**
//	 * @param ciphertext 密文
//	 * @param key key
//	 * @return 原文
//	 * 
//	 */
//	public static String decodeAES(final byte[] ciphertext, String key, String secretiv, String provider) throws IllegalBlockSizeException, BadPaddingException, NoSuchProviderException
//	{
//		if (ciphertext == null || ciphertext.length == 0)
//		{
//			return null;
//		}
//		if (key == null || key.length() == 0)
//		{
//			key = "yh@snsoft.com.cn";
//		}
//		key = StrUtil.getEquilongString(key, 16);
//		try
//		{
//			KeyGenerator kgen = KeyGenerator.getInstance("AES");
//			SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
//			secureRandom.setSeed(key.getBytes());
//			kgen.init(128, secureRandom);
//			final byte[] raw = kgen.generateKey().getEncoded();
//			final SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
//			Cipher cipher = null;
//			if (StrUtil.isNotStrTrimNull(provider))
//			{
//				cipher = Cipher.getInstance("AES", provider);
//			} else
//			{
//				cipher = Cipher.getInstance("AES");
//			}
//			if (secretiv == null || secretiv.length() == 0)
//			{
//				cipher.init(Cipher.DECRYPT_MODE, skeySpec);
//			} else
//			{
//				final IvParameterSpec iv = new IvParameterSpec(secretiv.getBytes());
//				cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
//			}
//			final byte[] original = cipher.doFinal(ciphertext);
//			return new String(original, "UTF-8");
//		} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | InvalidAlgorithmParameterException | UnsupportedEncodingException e)
//		{
//			throw new RuntimeException("解密算法初始化失败!", e);
//		}
//	}
//
//	public static String decodeAES(final byte[] ciphertext) throws IllegalBlockSizeException, BadPaddingException, NoSuchProviderException
//	{
//		return SecurityUtil.decodeAES(ciphertext, "yh@snsoft.com.cn", null);
//	}
//
//	//TODO:DES、3DES、Blowfish、IDEA、RC4、RC5、RC6等常用算法
//	/*------------------------------------------非对称算法--------------------------------------------*/
//	/**
//	 * RAS加密
//	 * @param original 原文
//	 * @param key 密钥
//	 * @return 密文(Base64编码)
//	 * 		破解难度高,没有已知的通用破解办法;但是加密解密速度都很慢,适合较小数据量的加密
//	 */
//	public static String encryptRSA(final String original, final Key key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException,
//			IOException
//	{
//		if (original == null || original.length() == 0)
//		{
//			return null;
//		}
//		final Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
//		cipher.init(Cipher.ENCRYPT_MODE, key);
//		final byte[] code = original.getBytes("UTF-8");
//		final int size = 117;//这个数值尽可能大,使加密后的数据尽可能小.
//		final ByteBuffer bbf = ByteBuffer.allocate(128 * (int) Math.ceil(1.0 * code.length / size));
//		int p = 0;
//		do
//		{
//			bbf.put(cipher.doFinal(code, p, p + size < code.length ? size : code.length - p));
//		} while ((p += size) < code.length);
//		final String encryptedText = SecurityUtil.encodeBASE64(bbf.array());
//		return encryptedText;
//	}
//
//	/**
//	 * RAS解密
//	 * @param ciphertext 密文(Base64编码)
//	 * @param key 密钥
//	 * @return 解密后的内容
//	 */
//	public static String decryptRSA(final String ciphertext, final Key key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IOException, IllegalBlockSizeException,
//			BadPaddingException
//	{
//		if (ciphertext == null || ciphertext.length() == 0)
//		{
//			return null;
//		}
//		final Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
//		cipher.init(Cipher.DECRYPT_MODE, key);
//		final byte code[] = SecurityUtil.decodeBASE64(ciphertext, true);
//		final StringBuilder sb = new StringBuilder();
//		int p = 0;
//		do
//		{
//			sb.append(new String(cipher.doFinal(code, p, 128), "UTF-8"));
//		} while ((p += 128) < code.length);
//		return sb.toString();
//	}
//
//	/**
//	 * 通过公钥字符串获取公钥
//	 * @param key 字符串
//	 * @param provider  {@see Security.getProviders()}
//	 * @return 公钥对象
//	 */
//	public static PublicKey getRSAPublicKeyFromString(final String key, final String provider) throws InvalidKeySpecException, IOException
//	{
//		return SecurityUtil.getRSAPublicKey(SecurityUtil.decodeBASE64(key, true), provider);
//	}
//
//	/**
//	 * 通过公钥文件获取公钥
//	 * @param key 字符串
//	 * @param provider  {@see Security.getProviders()}
//	 * @return 公钥对象
//	 */
//	public static PublicKey getRSAPublicKeyFromFile(final String keyFileName, final String provider) throws IOException, InvalidKeySpecException
//	{
//		try (FileInputStream is = new FileInputStream(keyFileName))
//		{
//			final int type = IOStreamUtil.readInt(is);
//			if (type != 1)
//			{
//				throw new RuntimeException("文件类型错误:不是需要是Key文件!");
//			}
//			final int length = IOStreamUtil.readInt(is);
//			final byte[] b = new byte[length];
//			is.read(b);
//			return SecurityUtil.getRSAPublicKey(b, provider);
//		}
//	}
//
//	/**
//	 * 通过公钥二进制字节数组串获取公钥
//	 * @param key 字节数组
//	 * @param provider {@see Security.getProviders()}
//	 * @return 公钥对象
//	 */
//	public static PublicKey getRSAPublicKey(final byte[] key, final String provider) throws InvalidKeySpecException
//	{
//		final EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(key);
//		try
//		{
//			final KeyFactory keyFactory = provider == null ? KeyFactory.getInstance("RSA") : KeyFactory.getInstance("RSA", provider);
//			final PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
//			return publicKey;
//		} catch (NoSuchAlgorithmException | NoSuchProviderException e)
//		{
//			throw new RuntimeException(e);
//		}
//	}
//
//	/**
//	 * 通过私钥字符串获取私钥
//	 * @param key 字符串
//	 * @param provider {@see Security.getProviders()}
//	 * @return 私钥对象
//	 */
//	public static PrivateKey getRSAPrivateKeyFromString(final String key, final String provider) throws Exception
//	{
//		return SecurityUtil.getRSAPrivateKey(SecurityUtil.decodeBASE64(key, true), provider);
//	}
//
//	public static PrivateKey getRSAPrivateKeyFromFile(final String keyFileName, final String provider) throws Exception
//	{
//		try (FileInputStream is = new FileInputStream(keyFileName))
//		{
//			final int type = IOStreamUtil.readInt(is);
//			if (type != 2)
//			{
//				throw new RuntimeException("文件类型错误:不是需要是Key文件!");
//			}
//			final int length = IOStreamUtil.readInt(is);
//			final byte[] b = new byte[length];
//			is.read(b);
//			return SecurityUtil.getRSAPrivateKey(b, provider);
//		}
//	}
//
//	/**
//	 * 通过私钥二进制字节数组获取私钥
//	 * @param key 字节数组
//	 * @param provider {@see Security.getProviders()}
//	 * @return 私钥对象
//	 */
//	public static PrivateKey getRSAPrivateKey(final byte[] key, final String provider) throws Exception
//	{
//		final KeyFactory keyFactory = provider == null ? KeyFactory.getInstance("RSA") : KeyFactory.getInstance("RSA", provider);
//		final EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(key);
//		final PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);
//		return privateKey;
//	}
//
//	public static void generateRSAPairKey()
//	{
//		SecurityUtil.generateRSAPairKey(null);
//	}
//
//	/**
//	 * 生成公私钥对,打印到控制台!
//	 * 同时打印字符串形式的和二进制字节形式的两种
//	 * @param filePath 生成的密钥文件路径
//	 */
//	public static void generateRSAPairKey(final String filePath)
//	{
//		try
//		{
//			final KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
//			keyGen.initialize(1024);
//			final KeyPair key = keyGen.generateKeyPair();
//			final java.security.PublicKey publicKey = key.getPublic();
//			final java.security.PrivateKey privateKey = key.getPrivate();
//			final byte[] publicKeyBytes = publicKey.getEncoded();
//			final byte[] privateKeyBytes = privateKey.getEncoded();
//			if (filePath != null)
//			{
//				final File publicKeyFile = new File(filePath + "/PublicKey.key");
//				final File privateKeyFile = new File(filePath + "/PrivateKey.key");
//				if (publicKeyFile.exists() || privateKeyFile.exists())
//				{
//					throw new RuntimeException("密钥文件存在!");
//				}
//				try (FileOutputStream fos = new FileOutputStream(publicKeyFile))
//				{
//					IOStreamUtil.writeInt(fos, 1);//类型,1表示公钥
//					IOStreamUtil.writeInt(fos, publicKeyBytes.length);
//					fos.write(publicKeyBytes);
//					fos.flush();
//				}
//				try (FileOutputStream fos = new FileOutputStream(privateKeyFile))
//				{
//					IOStreamUtil.writeInt(fos, 2);//类型,2表示私钥
//					IOStreamUtil.writeInt(fos, privateKeyBytes.length);
//					fos.write(privateKeyBytes);
//					fos.flush();
//				}
//			}
//			System.out.println("publicKey.length=" + publicKeyBytes.length);
//			System.out.println("PriKeyS.length=" + privateKeyBytes.length);
//			final String publicKeyText = SecurityUtil.encodeBASE64(publicKeyBytes);
//			final String privateKeyText = SecurityUtil.encodeBASE64(privateKeyBytes);
//			System.out.println("PubKeyString=" + publicKeyText);
//			System.out.println("PriKeyString=" + privateKeyText);
//			PubUtil.printJavaCode(publicKey.getEncoded(), "publicKeyBytes", "//公钥二进制:");
//			PubUtil.printJavaCode(privateKey.getEncoded(), "privateKeyBytes", "//私钥二进制:");
//			System.out.println("建议使用二进制表示方式!");
//			// 使用 ：
//			final java.security.PublicKey publicKey2 = SecurityUtil.getRSAPublicKeyFromString(publicKeyText, null);
//			final java.security.PrivateKey privateKey2 = SecurityUtil.getRSAPrivateKeyFromString(privateKeyText, null);
//			final java.security.PublicKey publicKey3 = SecurityUtil.getRSAPublicKey(publicKeyBytes, null);
//			final java.security.PrivateKey privateKey3 = SecurityUtil.getRSAPrivateKey(privateKeyBytes, null);
//			System.out.println("检查密钥可用性:");
//			System.out.println("publicKeyBytes:" + publicKey.equals(publicKey3));
//			System.out.println("privateKeyBytes:" + privateKey.equals(privateKey3));
//			System.out.println("PubKeyString:" + publicKey.equals(publicKey2));
//			System.out.println("PriKeyString:" + privateKey.equals(privateKey2));
//		} catch (final Throwable ex)
//		{
//			throw new RuntimeException(ex);
//		}
//	}
//
//	//TODO:ECC（移动设备用）、Diffie-Hellman、El Gamal、DSA（数字签名用）等算法
//	/*---------------------------------------不可逆算法-Hash摘要----------------------------------------*/
//	/**
//	 * SHA-1算法计算Hash摘要
//	 * @param original 原文
//	 * @return MD5的计算结果
//	 */
//	public static byte[] encodeMD5(final byte[] original) throws NoSuchAlgorithmException
//	{
//		final MessageDigest md = MessageDigest.getInstance("MD5");
//		md.reset();
//		md.update(original);
//		return md.digest();
//	}
//
//	public static byte[] encodeMD5(final String original) throws NoSuchAlgorithmException
//	{
//		if (original == null || original.length() == 0)
//		{
//			return null;
//		}
//		return SecurityUtil.encodeMD5(original.getBytes());
//	}
//
//	public static String encodeMD5AsHexString(final byte[] original) throws IOException, NoSuchAlgorithmException
//	{
//		final byte[] md5Array = SecurityUtil.encodeMD5(original);
//		return StrUtil.toHexString(md5Array);
//	}
//
//	public static String encodeMD5AsHexString(final String original) throws IOException, NoSuchAlgorithmException
//	{
//		final byte[] md5Array = SecurityUtil.encodeMD5(original);
//		return StrUtil.toHexString(md5Array);
//	}
//
//	public static String encodeMD5AsBase64String(final byte[] original) throws IOException, NoSuchAlgorithmException
//	{
//		final byte[] md5Array = SecurityUtil.encodeMD5(original);
//		return SecurityUtil.encodeBASE64(md5Array);
//	}
//
//	public static String encodeMD5AsBase64String(final String original) throws IOException, NoSuchAlgorithmException
//	{
//		final byte[] md5Array = SecurityUtil.encodeMD5(original);
//		return SecurityUtil.encodeBASE64(md5Array);
//	}
//
//	/**
//	 * SHA-1算法计算Hash摘要
//	 * @param original 原文
//	 * @return SHA-1计算结果
//	 * 		一般用于文件的数字校验码
//	 */
//	public static byte[] encodeSHA1(final byte[] original) throws NoSuchAlgorithmException
//	{
//		final MessageDigest md = MessageDigest.getInstance("SHA-1");
//		md.reset();
//		md.update(original);
//		return md.digest();
//	}
//
//	public static byte[] encodeSHA1(final String original) throws NoSuchAlgorithmException
//	{
//		if (original == null || original.length() == 0)
//		{
//			return null;
//		}
//		return SecurityUtil.encodeSHA1(original.getBytes());
//	}
//
//	public static String encodeSHA1AsHexString(final byte[] original) throws IOException, NoSuchAlgorithmException
//	{
//		final byte[] md5Array = SecurityUtil.encodeSHA1(original);
//		return StrUtil.toHexString(md5Array);
//	}
//
//	public static String encodeSHA1AsHexString(final String original) throws IOException, NoSuchAlgorithmException
//	{
//		final byte[] md5Array = SecurityUtil.encodeSHA1(original);
//		return StrUtil.toHexString(md5Array);
//	}
//
//	public static String encodeSHA1AsBase64String(final byte[] original) throws IOException, NoSuchAlgorithmException
//	{
//		final byte[] md5Array = SecurityUtil.encodeSHA1(original);
//		return SecurityUtil.encodeBASE64(md5Array);
//	}
//
//	public static String encodeSHA1AsBase64String(final String original) throws IOException, NoSuchAlgorithmException
//	{
//		final byte[] md5Array = SecurityUtil.encodeSHA1(original);
//		return SecurityUtil.encodeBASE64(md5Array);
//	}
//
//	//TODO:HAVAL,CRC32算法
//	/*---------------------------------------------无损压缩------------------------------------------------*/
//	//GZip,LZMA算法
//	/*-----------------------------------------------测试-------------------------------------------------*/
//	public static void main(final String[] args) throws Exception
//	{
//		//		generateRSAPairKey();
//		//		testBASE64();
//		//		SecurityUtil.testEncodeSimpleXor();
//		//		SecurityUtil.testRES();
//		//generateRSAPairKey("D:/Cache/");
//		//		SecurityUtil.testRSA();//有问题!
//	}
//
//	static void testBASE64() throws Exception
//	{
//		final String s = "国务院13日上午召开全国电视电话会议,动员部署国务院机构职能转变工作.中共中央政治局常委,国务院总理李克强发表讲话.他强调,要贯彻落实党的十八届二中全会和国务院第一次全体会议精神,处理好政府与市场,政府与社会的关系,把该放的权力放掉,把该管的事务管好,激发市场主体创造活力,增强经济发展内生动力,把政府工作重点转到创造良好发展环境,提供优质公共服务,维护社会公平正义上来.";
//		final long t0 = System.currentTimeMillis();
//		final String ciphertext = SecurityUtil.encodeBASE64(s);
//		final long t1 = System.currentTimeMillis();
//		final String original = SecurityUtil.decodeBASE64AsString(ciphertext, true);
//		final long t2 = System.currentTimeMillis();
//		System.out.println("加密后的字串是：" + ciphertext);
//		System.out.println("加密耗时：" + (t1 - t0) + "毫秒");
//		System.out.println("解密后的字串是：" + original);
//		System.out.println("解密耗时：" + (t2 - t1) + "毫秒");
//	}
//
//	static void testRES() throws Exception
//	{
//		/*
//		加密用的Key
//		可以用26个字母和数字组成，最好不要用保留字符
//		 */
//		final String key = "中华人民共和国";
//		//需要加密的字串
//		final String s = "国务院13日上午召开全国电视电话会议,动员部署国务院机构职能转变工作.中共中央政治局常委,国务院总理李克强发表讲话.他强调,要贯彻落实党的十八届二中全会和国务院第一次全体会议精神,处理好政府与市场,政府与社会的关系,把该放的权力放掉,把该管的事务管好,激发市场主体创造活力,增强经济发展内生动力,把政府工作重点转到创造良好发展环境,提供优质公共服务,维护社会公平正义上来.";
//		//加密
//		long lStart = System.currentTimeMillis();
//		final String ciphertext = SecurityUtil.encodeAES(s, key, null);
//		System.out.println("加密后的字串是：" + ciphertext);
//		long lUseTime = System.currentTimeMillis() - lStart;
//		System.out.println("加密耗时：" + lUseTime + "毫秒");
//		//解密
//		lStart = System.currentTimeMillis();
//		final String original = SecurityUtil.decodeAES(SecurityUtil.decodeBASE64(ciphertext, true), key, null);
//		System.out.println("解密后的字串是：" + original);
//		lUseTime = System.currentTimeMillis() - lStart;
//		System.out.println("解密耗时：" + lUseTime + "毫秒");
//	}
//
//	static void testEncodeSimpleXor()
//	{
//		final String s = "国务院13日上午召开全国电视电话会议,动员部署国务院机构职能转变工作.中共中央政治局常委,国务院总理李克强发表讲话.他强调,要贯彻落实党的十八届二中全会和国务院第一次全体会议精神,处理好政府与市场,政府与社会的关系,把该放的权力放掉,把该管的事务管好,激发市场主体创造活力,增强经济发展内生动力,把政府工作重点转到创造良好发展环境,提供优质公共服务,维护社会公平正义上来.";
//		System.err.println(s);
//		final String encodeSimpleXor = SecurityUtil.encodeSimpleXor(s);
//		System.err.println(encodeSimpleXor);
//		final String encodeSimpleXor2 = SecurityUtil.encodeSimpleXor(encodeSimpleXor);
//		System.err.println(encodeSimpleXor2);
//		final String decodeSimpleXor = SecurityUtil.decodeSimpleXor(encodeSimpleXor2);
//		System.err.println(decodeSimpleXor);
//		final String decodeSimpleXor2 = SecurityUtil.decodeSimpleXor(decodeSimpleXor);
//		System.err.println(decodeSimpleXor2);
//	}
//
//	static void testRSA() throws Exception
//	{
//		//generateRSAPairKey();
//		//PublicKey rsaPublicKey = getRSAPublicKeyFromFile("D:/Cache/PublicKey.key", null);
//		//PrivateKey rsaPrivateKey = getRSAPrivateKeyFromFile("D:/Cache/PrivateKey.key", null);
//		//将生成的密钥粘贴到下面:
//		//公钥二进制:
//		final byte[] publicKeyBytes = new byte[] { 48, -127, -97, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 1, 5, 0, 3, -127, -115, 0, 48, -127, -119, 2, -127, -127, 0, -112, -14, -94, 78, 84,
//				-29, -53, -106, 86, 74, 98, 7, -34, 4, -91, 122, 96, -10, 10, 84, 115, 92, -126, 52, -6, 47, 25, 52, 4, 94, -81, -125, -82, -44, 77, 98, -94, 122, 36, 112, -55, 67, 37, 67, -9, 118,
//				83, 26, 79, 23, -24, 71, 16, -40, 27, -87, -5, 15, -103, -115, -94, 56, 13, -25, -52, -95, 107, 121, -128, -106, 104, 108, -56, -42, 49, 50, -120, 67, -28, 5, 114, 74, -45, 95, 107,
//				-114, -57, -51, 80, -38, -75, -11, 106, 33, -81, 124, 10, 30, -34, -74, -97, -82, -88, -73, -96, 59, -3, 105, -88, -93, 68, -19, -20, 49, 43, -95, -77, -6, -81, -36, 74, 0, -12, -67,
//				-86, 54, -15, -35, 2, 3, 1, 0, 1 };
//		//私钥二进制:
//		final byte[] privateKeyBytes = new byte[] { 48, -126, 2, 118, 2, 1, 0, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 1, 5, 0, 4, -126, 2, 96, 48, -126, 2, 92, 2, 1, 0, 2, -127, -127, 0,
//				-112, -14, -94, 78, 84, -29, -53, -106, 86, 74, 98, 7, -34, 4, -91, 122, 96, -10, 10, 84, 115, 92, -126, 52, -6, 47, 25, 52, 4, 94, -81, -125, -82, -44, 77, 98, -94, 122, 36, 112,
//				-55, 67, 37, 67, -9, 118, 83, 26, 79, 23, -24, 71, 16, -40, 27, -87, -5, 15, -103, -115, -94, 56, 13, -25, -52, -95, 107, 121, -128, -106, 104, 108, -56, -42, 49, 50, -120, 67, -28,
//				5, 114, 74, -45, 95, 107, -114, -57, -51, 80, -38, -75, -11, 106, 33, -81, 124, 10, 30, -34, -74, -97, -82, -88, -73, -96, 59, -3, 105, -88, -93, 68, -19, -20, 49, 43, -95, -77, -6,
//				-81, -36, 74, 0, -12, -67, -86, 54, -15, -35, 2, 3, 1, 0, 1, 2, -127, -128, 14, -20, 27, -49, -118, -89, -60, -2, -34, 53, 92, 48, 73, 40, 27, 77, 37, 12, 79, 117, -16, 70, 118, -43,
//				51, 104, -125, -28, -70, 10, 113, 113, 82, 31, 99, 52, 35, 92, 5, -62, 98, -59, -7, -31, 44, 105, -49, 22, 103, 76, 35, -54, -91, 46, 74, 114, -50, 121, 5, -86, -14, 39, 105, 46, -21,
//				73, -19, -8, 21, 86, -18, 21, -2, -37, 38, -114, -67, 5, -98, -99, -107, -62, -65, 77, 28, 62, 9, 79, -6, 104, 123, 82, -16, -58, -19, -66, -57, 117, 84, 117, 98, 77, -118, 30, -113,
//				122, 48, -104, -45, 121, -128, 9, -53, 33, 40, 69, 97, -61, 100, -21, -120, -86, -75, 125, 126, 12, 100, -127, 2, 65, 0, -54, 8, -87, -101, 81, -126, -32, 71, -80, -104, -127, -51,
//				-81, -115, 111, 6, 63, 68, -15, -84, 97, -90, 37, -114, 11, 53, -52, 74, 95, 38, -115, 103, -55, -122, 117, 98, 74, -19, -66, -112, -110, 33, -57, -33, -116, 119, -18, 125, -90, -65,
//				123, -50, -126, 117, -116, -37, 104, 57, 18, -127, -1, 58, 64, -95, 2, 65, 0, -73, -86, 90, 92, 7, 70, 23, -23, -73, 103, -55, 51, 1, 115, 31, 80, 117, 95, 79, 121, 39, -61, -98, 86,
//				-89, -56, -28, -121, -93, 112, -88, -6, 16, 103, 100, 123, -52, -11, -112, 47, -72, -86, 41, 72, -118, -52, 79, 55, -31, -59, 47, 6, -43, 15, -34, 26, 33, 44, -118, 60, 113, -68, 91,
//				-67, 2, 64, 58, 28, -31, -60, 102, 94, -47, -22, 109, 22, -127, 7, -53, -2, 79, -72, 41, 76, -56, -125, 64, 23, 77, 104, 29, 59, 93, 70, -21, 53, -88, -88, -8, -29, -81, 50, 21, -63,
//				106, -10, 36, -62, -120, -66, 121, -90, 41, -72, -124, -43, 65, 100, 118, 76, 31, -73, 32, -76, -127, -23, 88, -93, -59, -31, 2, 65, 0, -96, 109, 103, -62, 45, 4, 87, -52, -23, 75,
//				-7, -99, -40, -19, 82, -13, -9, -94, 10, 12, 60, -28, -115, 1, 10, 75, -38, -6, 115, -109, -21, -75, -119, -16, -107, -1, -31, 118, -71, -68, 69, 100, 52, -19, 77, 119, -54, -42, 120,
//				25, -63, -53, 8, -2, 116, 53, -124, -74, -96, 4, -50, 32, 6, 77, 2, 64, 20, 39, 6, 125, 102, -42, -99, 44, -22, 125, -118, 70, 87, 9, -8, -20, -63, -72, -57, 105, -124, -126, 120, 52,
//				-90, 86, -22, 80, 119, -76, -92, 75, 28, 22, 70, -24, 67, -103, 111, -25, -28, 35, -24, -69, -59, -93, 12, 112, -58, -17, 96, 82, 51, 90, -4, 10, 56, -117, 58, 51, -45, -62, 2, 124 };
//		//待加密测试字符串
//		String s = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n";
//		s += "<members>\r\n";
//		s += "	<member>\r\n";
//		s += "		<id>0001</id>\r\n";
//		s += "		<mobile>1380138000</mobile>\r\n";
//		s += "		<email>wanglipeng@snsoft.com.cn</email>\r\n";
//		s += "		<fcombcode>00000001</fcombcode>\r\n";
//		s += "		<fcomname>吉野家</fcomname>\r\n";
//		s += "		<netindate>2013-4-23 13:37:29</netindate>\r\n";
//		s += "		<fuserlevelicode>20</fuserlevelicode>\r\n";
//		s += "		<fuserlevelname>VIP2会员</fuserlevelname>\r\n";
//		s += "		<realname>王立鹏</realname>\r\n";
//		s += "		<oldmemberno>0001</oldmemberno>\r\n";
//		s += "		<cardno>569878154</cardno>\r\n";
//		s += "		<address>北京市海淀区</address>\r\n";
//		s += "		<postcode>100859</postcode>\r\n";
//		s += "		<certno>26548119840224561X</certno>\r\n";
//		s += "	</member>\r\n";
//		s += "	<member>\r\n";
//		s += "		......\r\n";
//		s += "	</member>\r\n";
//		s += "</members>";
//		//		s = "15509273566";
//		s = "国务院13日上午召开全国电视电话会议,动员部署国务院机构职能转变工作.中共中央政治局常委,国务院总理李克强发表讲话.他强调,要贯彻落实党的十八届二中全会和国务院第一次全体会议精神,处理好政府与市场,政府与社会的关系,把该放的权力放掉,把该管的事务管好,激发市场主体创造活力,增强经济发展内生动力,把政府工作重点转到创造良好发展环境,提供优质公共服务,维护社会公平正义上来.";
//		//使用公钥加密,公钥加密后,每次密文都不一样
//		final PublicKey publicKey = SecurityUtil.getRSAPublicKey(publicKeyBytes, null);
//		final String encryptStr = SecurityUtil.encryptRSA(s, publicKey);
//		System.out.println("公钥加密后:\n" + encryptStr);
//		//使用私钥解密
//		final PrivateKey privateKey = SecurityUtil.getRSAPrivateKey(privateKeyBytes, null);
//		final String decryptStr = SecurityUtil.decryptRSA(encryptStr, privateKey);
//		System.out.println("私钥解密后:\n" + decryptStr);
//		System.out.println();
//		//反过来,类似数字证书
//		//使用私钥加密,私钥加密后,每次密文都相同
//		final String encryptStr2 = SecurityUtil.encryptRSA(s, privateKey);
//		System.out.println("私钥加密后:\n" + encryptStr2);
//		//使用公钥解密
//		final String decryptStr2 = SecurityUtil.decryptRSA(encryptStr2, publicKey);
//		System.out.println("公钥解密后:\n" + decryptStr2);
//	}
}
